/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package PandoraBoxController;

import Services.AppService;
import Services.UsuarioService.UsuarioService;
import com.opensymphony.xwork2.ModelDriven;
import exeptions.GeneralException;
import java.util.ArrayList;
import mapeos.Archivo;
import mapeos.Usuario;
import utils.ArchUtils;

/**
 *
 * @author ivanpianetti
 */
public class PandoraBoxController implements ModelDriven {

    private Usuario usuario = UsuarioService.getUsuarioActual();
    private Archivo carpetaActual = new Archivo();
    private ArrayList<Usuario> listaUsuarios = new ArrayList<Usuario>();
    private ArrayList<Archivo> listaArchivos = new ArrayList<Archivo>();
    private String mensaje = "";
    private String nombreUsuario = null;
    private String mailUsuario = null;
    private String username = null;
    private String password = null;
    private String passwordRepeat = null;
    //
    private String nombreElementoArchivo = null;
    private String mailUsuarioCompartir = null;
    private int idElementoArchivo = -1;
    //
    private static String resultOK = "resultOK";
    private static String resultError = "resultError";

    public Usuario getModel() {
        return null;
    }

    public String methodLogIn() {
        try {
            usuario = AppService.getInstance().getUsuarioService().logIn(username, password);
            if (usuario == null) {
                mensaje = "Usuario o clave incorrecta.";
            } else {
                carpetaActual = AppService.getInstance().getArchivoService().getCarpetaHomeByUsuario(usuario);
                this.methodListarArchivosByCarpeta();
                return resultOK;
            }
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        return resultError;
    }

    public String methodListarArchivosByCarpeta() {
        try {
            this.cargarCarpetaActual();
            listaArchivos = new ArrayList<Archivo>();
            listaArchivos.addAll(AppService.getInstance().getArchivoService().getAllByCarpeta(carpetaActual));

        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        return resultOK;
    }

    public String methodIngresarACarpeta() {
        try {
            Archivo arch = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
            if (arch.isCarpeta()) {
                carpetaActual = arch;
            }
            this.methodListarArchivosByCarpeta();
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        return resultOK;
    }

    public String methodSalirDeCarpeta() {
        try {
            Archivo arch = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
            this.calcularPadreCarpeta(arch);
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        this.methodListarArchivosByCarpeta();
        return resultOK;
    }

    public String methodNuevaCarpeta() {
        try {
            Archivo arch = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
            if (arch.isCarpeta()) {
                carpetaActual = arch;
                String nombreMadre = carpetaActual.getNombreArchivo();
                carpetaActual.setNombreArchivo(nombreElementoArchivo);
                AppService.getInstance().getArchivoService().crearCarpeta(carpetaActual);
                carpetaActual.setNombreArchivo(nombreMadre);
            }
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        this.methodListarArchivosByCarpeta();
        return resultOK;
    }

    public String methodOpcionDeCompartirCarpeta() {
        try {
            carpetaActual = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
            if (carpetaActual.isCarpetaCompartible()) {
                listaUsuarios = new ArrayList<Usuario>();
                listaUsuarios.addAll(AppService.getInstance().getUsuarioService().getAllByGrupo(carpetaActual.getGrupo()));
            }
            this.methodListarArchivosByCarpeta();
            return resultOK;
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        return resultError;
    }

    public String methodCompartirCarpeta() {
        try {
            Archivo carpeta = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
            Usuario user = AppService.getInstance().getUsuarioService().getByMail(mailUsuarioCompartir);
            AppService.getInstance().getArchivoService().compartirCarpeta(carpeta, user);
            carpetaActual = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
            listaUsuarios = new ArrayList<Usuario>();
            listaUsuarios.addAll(AppService.getInstance().getUsuarioService().getAllByGrupo(carpetaActual.getGrupo()));
            this.methodListarArchivosByCarpeta();
            listaUsuarios = new ArrayList<Usuario>();
            listaUsuarios.addAll(AppService.getInstance().getUsuarioService().getAllByGrupo(carpetaActual.getGrupo()));
            return resultOK;
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        this.methodOpcionDeCompartirCarpeta();
        return resultError;
    }

    public String methodEliminarArchivo() {
        try {
            Archivo archToDelete = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
            this.calcularPadreCarpeta(archToDelete);
            AppService.getInstance().getArchivoService().delete(archToDelete);
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        this.methodListarArchivosByCarpeta();
        return resultOK;
    }

    public String methodSubirArchivo() {
        try {
            this.cargarCarpetaActual();
            String filePath = ArchUtils.seleccionarArchivo();
            AppService.getInstance().getArchivoService().subirArchivo(filePath, carpetaActual);
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        this.methodListarArchivosByCarpeta();
        return resultOK;
    }

    public String methodDescargarArchivo() {
        try {
            Archivo archToDownload = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
            if (archToDownload != null) {
                String rutaArchivo = ArchUtils.guardarComoArchivo(archToDownload.getNombreArchivo());
                AppService.getInstance().getArchivoService().descargarArchivo(rutaArchivo, archToDownload);
            }
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
        this.methodListarArchivosByCarpeta();
        return resultOK;
    }

    public String methodEditarArchivo() {
        return resultError;
    }

    /**
     * Permite registrar un nuevo usuario
     * @return 
     */
    public String methodRegistro() {
        if (password.equals(passwordRepeat)) {
            Usuario nuevoUser = new Usuario(nombreUsuario, username, password, mailUsuario);
            try {
                AppService.getInstance().getUsuarioService().insert(nuevoUser);
                return resultOK;
            } catch (GeneralException ex) {
                mensaje = ex.getMessage();
            }
        } else {
            mensaje = "La clave es diferente de su comprobación";
        }
        return resultError;
    }

    /**
     * Permite editar el perfil o los datos del usuario
     * @return 
     */
    public String methodPerfil() {
        if (password.equals(passwordRepeat)) {
            usuario.setNombreUsuario(nombreUsuario);
            usuario.setClaveUsuario(password);
            usuario.setMailUsuario(mailUsuario);
            try {
                AppService.getInstance().getUsuarioService().update(usuario);
                mensaje = "Ingrese nuevamente.";
                return resultOK;
            } catch (GeneralException ex) {
                mensaje = ex.getMessage();
            }
        } else {
            mensaje = "La clave es diferente de su comprobación.";
        }
        return resultError;
    }

    //<editor-fold defaultstate="collapsed" desc="Get & Set">
    public int getIdElementoArchivo() {
        return idElementoArchivo;
    }

    public void setIdElementoArchivo(int idElementoArchivo) {
        this.idElementoArchivo = idElementoArchivo;
    }

    public String getNombreElementoArchivo() {
        return nombreElementoArchivo;
    }

    public void setNombreElementoArchivo(String nombreElementoArchivo) {
        this.nombreElementoArchivo = nombreElementoArchivo;
    }

    public String getMailUsuarioCompartir() {
        return mailUsuarioCompartir;
    }

    public void setMailUsuarioCompartir(String mailUsuarioCompartir) {
        this.mailUsuarioCompartir = mailUsuarioCompartir;
    }

    public ArrayList<Archivo> getListaArchivos() {
        return listaArchivos;
    }

    public void setListaArchivos(ArrayList<Archivo> listaArchivos) {
        this.listaArchivos = listaArchivos;
    }

    public ArrayList<Usuario> getListaUsuarios() {
        return listaUsuarios;
    }

    public void setListaUsuarios(ArrayList<Usuario> listaUsuarios) {
        this.listaUsuarios = listaUsuarios;
    }

    public String getMailUsuario() {
        return mailUsuario;
    }

    public void setMailUsuario(String mailUsuario) {
        this.mailUsuario = mailUsuario;
    }

    public String getMensaje() {
        return mensaje;
    }

    public void setMensaje(String mensaje) {
        this.mensaje = mensaje;
    }

    public String getNombreUsuario() {
        return nombreUsuario;
    }

    public void setNombreUsuario(String nombreUsuario) {
        this.nombreUsuario = nombreUsuario;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPasswordRepeat() {
        return passwordRepeat;
    }

    public void setPasswordRepeat(String passwordRepeat) {
        this.passwordRepeat = passwordRepeat;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Usuario getUsuario() {
        return usuario;
    }

    public void setUsuario(Usuario usuario) {
        this.usuario = usuario;
    }

    public Archivo getCarpetaActual() {
        return carpetaActual;
    }

    public void setCarpetaActual(Archivo carpetaActual) {
        this.carpetaActual = carpetaActual;
    }
    //</editor-fold>

    /**
     * Determina y calcula en la carpetaActual cuál es la carpeta padre 
     * correspondiendte a una carpeta hija
     * @param arch carpeta hija
     */
    private void calcularPadreCarpeta(Archivo arch) {
        try {
            if (arch.isCarpeta()) {
                if (arch.isCarpetaCompartible()) {
                    carpetaActual = AppService.getInstance().getArchivoService().getCarpetaHomeByUsuario(usuario);
                } else {
                    carpetaActual = arch.getCarpetaPadre();
                }
            } else {
                carpetaActual = arch.getCarpetaPadre();
            }
        } catch (GeneralException ex) {
            mensaje = ex.getMessage();
        }
    }

    /**
     * Verifica que la carpetaActual esté siempre OK.
     * Si no lo está se le asigna la carpeta correspondiente a idElementoArchivo seleccionado
     * @throws GeneralException 
     */
    private void cargarCarpetaActual() throws GeneralException {
        if (carpetaActual == null || carpetaActual.getNombreArchivo() == null) {// Si la carpeta actual es nula o corrupta
            if (idElementoArchivo == -1) {//si el id del archivo carpeta tiene el valor default
                carpetaActual = AppService.getInstance().getArchivoService().getCarpetaHomeByUsuario(usuario);//WAAAAAAA
            } else {//sino, se carga la carpeta segun el id
                Archivo arch = AppService.getInstance().getArchivoService().getById(idElementoArchivo);
                if (arch.isCarpeta()) { //Si es una carpeta => se pone como actual esa carpeta
                    carpetaActual = arch;
                } else {//Sino, se pone como carpeta actual al padre que corresponda
                    this.calcularPadreCarpeta(arch);
                }
            }
        }
    }
}
